
/*
 * CVect2d.cpp
 * Klasė darbui su dvimačiais vektoriais
 * 2009-05-20
 *
 */

#include "CVect2d.h"

#include <math.h>


// konstruktorius tuščias, pradinės reikšmės nepriskiriamos
CVect2d::CVect2d()
{
}

CVect2d::CVect2d( double x, double y )
{
    set( x, y );
}

CVect2d::CVect2d( const CVect2d &v )
{
    set( v.getX(), v.getY() );
}

// Destruktorius, tuščias
CVect2d::~CVect2d()		
{
}

// Įrašo kintamųjų reikšmes
void CVect2d::set( const double &x, const double &y )
{
    this->x = x;
    this->y = y;
}

void CVect2d::setX( const double &x )
{
    this->x = x;
}

void CVect2d::setY( const double &y )
{
    this->y = y;
}

// Grąžina kintamųjų reikšmes
void CVect2d::get( double &x, double &y ) const
{
    x = this->x;
    y = this->y;
}

double CVect2d::getX() const
{
    return x;
}

double CVect2d::getY() const
{
    return y;
}

// Gražina vektoriaus ilgį
double CVect2d::lenght() const
{
    return sqrt( x*x + y*y );
}

// Normalizuoja vektorių, 
void CVect2d::normalize()
{
    double m = lenght();

    if ( m == 0 )	// Nulinis vektorius lieka nulinis!
        return;		// Kad nebūtu dalybos iš 0

    Substract( m );
}

//  gražina normalizuotą vektorių
CVect2d CVect2d::direction() const
{
    CVect2d t( *this );
    t.normalize();
    return t;
}

// Operacijos pakeičiant vektorių
void CVect2d::Add( const CVect2d &v )
{
    x += v.getX();
    y += v.getY();
}

void CVect2d::Substract( const CVect2d &v )
{
    x -= v.getX();
    y -= v.getY();
}

void CVect2d::Multiply( const double &m )
{
    x *= m;
    y *= m;
}

void CVect2d::Substract( const double &m )
{
    x /= m;
    y /= m;
}

// Operatorių operacijos pakeičiančios vektorių
void CVect2d::operator += ( const CVect2d &v )
{
    x += v.getX();
    y += v.getY();
}

void CVect2d::operator -= ( const CVect2d &v )
{
    x -= v.getX();
    y -= v.getY();
}

void CVect2d::operator *= ( const double &m )
{
    x *= m;
    y *= m;
}

void CVect2d::operator /= ( const double &m )
{
    if ( m == 0 ) return;
    x /= m;
    y /= m;
}
	
// Operacijos grąžinančios rezultatą
CVect2d CVect2d::operator + ( const CVect2d &v ) const
{
    CVect2d t( *this );
    t += v;
    return t;
}

CVect2d CVect2d::operator - ( const CVect2d &v ) const
{
    CVect2d t( *this );
    t -= v;
    return t;
}

CVect2d CVect2d::operator * ( const double &m ) const
{
    CVect2d t( *this );
    t *= m;
    return t;
}

CVect2d CVect2d::operator / ( const double &m ) const
{
    CVect2d t( *this );
    t /= m;
    return t;
}

// Skaliarinė vektorių sandauga
double CVect2d::operator * ( const CVect2d &v ) const
{
    return x*v.getX() + y*v.getY();
}

// vektoriaus projekcija į vektorių v
CVect2d CVect2d::projectionTo( const CVect2d &v ) const
{
    CVect2d t( v.getX(), v.getY() );
    t *= dotProduct( *this, v ) / (v.getX()*v.getX() + v.getY()*v.getY());
    return t;
}

// Palyginimo operacijos
bool CVect2d::operator > ( const double &len ) const
{
    if ( lenght() > len )
        return true;
    return false;
}

bool CVect2d::operator >= ( const double &len ) const
{
    if ( lenght() >= len )
        return true;
    return false;
}

bool CVect2d::operator < ( const double &len ) const
{
    if ( lenght() < len )
        return true;
    return false;
}

bool CVect2d::operator <= ( const double &len ) const
{
    if ( lenght() <= len )
        return true;
    return false;
}

CVect2d CVect2d::leftNormal() const                         // Kairysis statmuo
{
    return CVect2d( y, -x );
}

CVect2d CVect2d::rightNormal() const                        // Dešinysis statmuo
{
    return CVect2d( -y, x );
}


/*
*/
